home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Systemmonitors / RSys / RSysSrc.lha / RSysBroker.c < prev    next >
C/C++ Source or Header  |  1993-09-19  |  7KB  |  326 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysBroker.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    void HandleBrokerPort ( void );
  12. *    void InstallBroker ( void );
  13. *    void RemoveBroker ( void );
  14. *
  15. *      --- Lokale  Routinen ---
  16. *
  17. *    static void HandleBrokerInputEventMsg ( ULONG msgid );
  18. *    static void HandleExchangeMsg ( ULONG msgid );
  19. *    static void InstallHotKeys ( void );
  20. *
  21. * Bemerkungen:
  22. *      Broker-Verwaltungsroutinen unter Verwendung der Commodities-Library.
  23. *
  24. * Erstellungsdatum:
  25. *      07-Jul-93     Rolf Böhme
  26. *
  27. * Änderungen:
  28. *      07-Jul-93     Rolf Böhme      Erstellung
  29. *
  30. ***************************************************************************
  31. */
  32.  
  33. #include "RSys.h"
  34.  
  35.     /*
  36.      * Der Zeiger auf den Brokerport. An diesem liegen
  37.      * die Nachrichten an, die vom Programm Exchange
  38.      * abgesendet werden.
  39.      */
  40. struct MsgPort *broker_mp = NULL;
  41.  
  42.     /*
  43.      * Die "Objekte", die die Eigenschaften der
  44.      * Nachrichten, die an den Broker gesendet werden
  45.      * sollen, festlegen.
  46.      */
  47. CxObj *broker,
  48.       *filter[HOTKEYS+1],
  49.       *sender,
  50.       *translate;
  51.  
  52.     /*
  53.      * Die Tastenkombinationen, mit denen RSys gesteuert
  54.      * werden kann.
  55.      */
  56. char    hotkey[HOTKEYS+1][30];
  57.  
  58.     /*
  59.      * In dieser Struktur werden alle Eigenschaften des
  60.      * Brokers definiert. Insbesondere der Name, die
  61.      * Version (systemabhängig), Eindeutigkeit des
  62.      * verwendeten Broker-Namens und ob Show/Hide-
  63.      * Nachrichten empfangen werden sollen.
  64.      */
  65. struct NewBroker newbroker =
  66. {
  67.     NB_VERSION,
  68.     NAME,
  69.     NAME " " VERSION " - " COPYRIGHT,
  70.     "RSys Commodity Handler",
  71.     NBU_UNIQUE,
  72.     NULL /*COF_SHOW_HIDE*/,
  73.     0,
  74.     0,
  75.     0
  76. };
  77.  
  78.     /*
  79.      * Ein Zeiger auf den letzten PublicScreen, auf dem
  80.      * das Hauptfenster von RSys geöffnet wurde.
  81.      */
  82. struct Screen *lastpubscreen = NULL;
  83.  
  84.     /*
  85.      * Die Prozedur InstallHotKeys() bildet für alle zu
  86.      * installierenden HotKeys einen Filter und bindet
  87.      * diese dann in die Broker-Struktur ein.
  88.      */
  89. static void
  90. InstallHotKeys(void)
  91. {
  92.     register int i;
  93.  
  94.     for (i = 0; i < HOTKEYS+1; i++)
  95.     {
  96.         filter[i] = HotKey((UBYTE *) & hotkey[i][0], broker_mp, (long)(i + 1));
  97.             /*
  98.              * Falls kein Filter erzeugt werden konnte, wird eine
  99.              * Fehlermeldung ausgegeben und das Programm beendet.
  100.              */
  101.         if (NOT(filter[i])) ErrorHandle((char *)hotkey[i][0], BROKER_ERR, CREATE_FAIL, KILL);
  102.  
  103.         AttachCxObj(broker, filter[i]);
  104.     }
  105.  
  106.     return;
  107. }
  108.  
  109.     /*
  110.      * InstallBroker() öffnet die commodities.library,
  111.      * richtet einen MessagePort für die Nachrichten vom
  112.      * Broker ein, initialisiert ein Broker-
  113.      * Kontrollstruktur und startet den Broker.
  114.      */
  115. void
  116. InstallBroker(void)
  117. {
  118.     DPOS;
  119.         /*
  120.          * Ein Kommunikations-Port wird erzeugt.
  121.          */
  122.     if (broker_mp = CreatePort((UBYTE *) "RSys-Broker-Port", 0L))
  123.     {
  124.         newbroker.nb_Port = broker_mp;
  125.         newbroker.nb_Pri    = 0;
  126.  
  127.             /*
  128.              * Falls der Broker erzeugt werden konnte, werden die
  129.              * HotKeys installiert und der Broker gestartet.
  130.              */
  131.         if (broker = CxBroker(&newbroker, NULL)) InstallHotKeys();
  132.         else
  133.             ErrorHandle(newbroker.nb_Name, BROKER_ERR, CREATE_FAIL, KILL);
  134.  
  135.         ActivateCxObj(broker, TRUE);
  136.     }
  137.     else ErrorHandle("RSys-Broker-Port", PORT_ERR, CREATE_FAIL, KILL);
  138.  
  139.     return;
  140. }
  141.  
  142.     /*
  143.      * RemoveBroker() entfernt alle mit dem Broker
  144.      * verbundenen Datenstrukturen aus dem System und
  145.      * schließt die commodities.library.
  146.      */
  147. void
  148. RemoveBroker(void)
  149. {
  150.     DPOS;
  151.  
  152.     if (broker)    DeleteCxObjAll(broker);
  153.     if (broker_mp) DeletePort(broker_mp);
  154.  
  155.     return;
  156. }
  157.  
  158. static void
  159. HandleBrokerInputEventMsg(ULONG msgid)
  160. {
  161.     struct Screen *activescr;
  162.         /*
  163.          * Dieses Feld von Funktionenzeigern enthält alle
  164.          * Funktionen, die entsprechend der MessageID
  165.          * ausgeführt werden.
  166.          */
  167.     void    (*func[HOTKEYS]) (void)=
  168.     {CryptFile, FindFile, FormatDisk, HunkStruct,CRCSum,SaveWindows, DisplayFileRequest};
  169.    int openit;
  170.  
  171.         /*
  172.          * Ist die MessageID 1, soll das RSys-Hauptfenster
  173.          * erscheinen.
  174.          */
  175.     if(msgid == 1)
  176.     {
  177.             /*
  178.              * Falls das Hauptfenster bereits offen ist, wird der
  179.              * nächst Public screen gesucht und versucht, RSys auf
  180.              * diesem Screen zu öffnen. War das erfolgreich, wird
  181.              * das ListView des Hauptfensters aktualisiert.
  182.              */
  183.         if (SysWnd)
  184.         {
  185.             activescr = SysWnd->WScreen;
  186.  
  187.             if (activescr != FindFrontPubScr(activescr))
  188.             {
  189.                 CloseASysWindow(&SysWnd, &SysGList, &SysMenus);
  190.                 CloseDownScreen();
  191.  
  192.                 OpenMainWindow();
  193.                 RefreshList(LastID);
  194.  
  195.             openit = CloseHelpOnScreen();
  196.             OpenHelpOnScreen(openit);
  197.             }
  198.         }
  199.         else
  200.         {
  201.                 /*
  202.                  * Ist das Hauptfenster noch nicht geöffnet, wird es
  203.                  * mit der Standardprozedur geöffnet und das ListView
  204.                  * aktualisiert.
  205.                  */
  206.             OpenMainWindow();
  207.             RefreshList(LastID);
  208.  
  209.          openit = CloseHelpOnScreen();
  210.          OpenHelpOnScreen(openit);
  211.         }
  212.     }
  213.     else
  214.     {
  215.             /*
  216.              * Ist die MessageID größer als 1, werden die
  217.              * entsprechenden Funktionen aus dem
  218.              * Funktionenzeigerfeld ausgeführt.  Ist das
  219.              * Hauptfenster noch nicht geöffnet worden, muß der
  220.              * Screen, auf dem das Fenster der jeweiligen
  221.              * Funktion geöffnet werden soll, mit SetupScreen()
  222.              * vorbereitet werden.
  223.              */
  224.         if (NOT(SysWnd))
  225.             if (SetupScreen()) ErrorHandle((char *)namebuffer, SCREEN_ERR, INFO_FAIL, NO_KILL);
  226.  
  227.         (*func[msgid - 2]) ();
  228.  
  229.         if (NOT(SysWnd)) CloseDownScreen();
  230.     }
  231.  
  232.    return;
  233. }
  234.  
  235. static void
  236. HandleExchangeMsg(ULONG msgid)
  237. {
  238.     switch (msgid)
  239.     {
  240.             /*
  241.              * Der Broker von RSys soll ausgeschaltet werden.
  242.              */
  243.         case CXCMD_DISABLE:
  244.             ActivateCxObj(broker, 0L);
  245.             break;
  246.  
  247.             /*
  248.              * Der Broker von RSys soll eingeschaltet werden.
  249.              */
  250.         case CXCMD_ENABLE:
  251.             ActivateCxObj(broker, 1L);
  252.             break;
  253.  
  254.             /*
  255.              * RSys soll ohne Sicherheitsabfrage beendet werden.
  256.              */
  257.         case CXCMD_KILL:
  258.             quit(FALSE);
  259.             break;
  260.  
  261.         case CXCMD_UNIQUE:
  262.                 /*
  263.                  * Ein Programm versucht einen Broker mit dem Namen
  264.                  * RSys einzurichten. Es erscheint eine Fehlermeldung.
  265.                  */
  266.             ErrorHandle(newbroker.nb_Name, BROKER_ERR, DUPLICATE_FAIL, NO_KILL);
  267.             break;
  268.     }
  269.  
  270.    return;
  271. }
  272.  
  273.     /*
  274.      * HandleBrokerPort() verarbeitet alle Nachrichten,
  275.      * die am Broker port eintreffen.
  276.      */
  277. void
  278. HandleBrokerPort(void)
  279. {
  280.     CxMsg *msg;
  281.     ULONG msgid,
  282.             msgtype;
  283.  
  284.     DPOS;
  285.         /*
  286.          * Alle Messages, die am Brokerport anliegen, werden
  287.          * bearbeitet.
  288.          */
  289.     while (msg = (CxMsg *) GetMsg(broker_mp))
  290.     {
  291.             /*
  292.              * Aus der Message werden die notwendigen Daten
  293.              * herauskopiert. Danach wird die Nachricht wieder
  294.              * so schnell wie möglich beantwortet, damit der
  295.              * Broker nicht wartet.
  296.              */
  297.         msgid = CxMsgID(msg);
  298.         msgtype = CxMsgType(msg);
  299.  
  300.         ReplyMsg((struct Message *) msg);
  301.  
  302.             /*
  303.              * Entsprechend dem Typ der Nachricht werden
  304.              * verschiedene Aktionen ausgelöst.
  305.              */
  306.         switch (msgtype)
  307.         {
  308.                 /*
  309.                  * Es handelt sich um einen Inputevent.
  310.                  */
  311.             case CXM_IEVENT:
  312.             HandleBrokerInputEventMsg(msgid);
  313.                 break;
  314.  
  315.                 /*
  316.                  * Es ist eine Nachricht vom Programm Exchange.
  317.                  */
  318.             case CXM_COMMAND:
  319.             HandleExchangeMsg(msgid);
  320.                 break;
  321.         }
  322.     }
  323.  
  324.     return;
  325. }
  326.